package main_task

import (
	"go_server/game_server/constants"
	"go_server/game_server/dao/task_info_dao"
	"go_server/game_server/dataconfig/config_manager"
	"go_server/game_server/protocol/pb"
	"go_server/game_server/util"
	"go_server/zinx/ziface"
	"go_server/zinx/zlog"
	"gorm.io/datatypes"
)

func (s *MainTaskService) S2C_UpdateMainTask(conn ziface.IConnection, roleId int64, taskType int32, taskEvent int32, params map[string]int32) pb.ErrorCodeManager {
	zlog.Infof("主线任务事件接收处理,taskType=%d,taskEvent=%d,params=%v", taskType, taskEvent, params)

	id := params["id"]     // 例如：建筑id或者关卡id,可传0
	num := params["value"] // 达成的数值

	// 当前主线任务-相关事件相关任务配置列表
	baseTaskList := config_manager.GetStcTableTask_SheetTaskListByEvent(taskType, taskEvent)
	if len(baseTaskList) == 0 {
		zlog.Errorf("baseTaskList 事件对应任务配置不存在,taskType=%d,taskEvent=%d", taskType, taskEvent)
		return pb.ErrorCodeManager_MAIN_TASK_UNFIND
	}

	// 获取当前用户主线任务进度
	fields := []string{"chapter", "main_task"}
	row := task_info_dao.GetTaskInfoByRoleId(roleId, fields)

	var chapter int32                           // 当前正在进行的章节
	taskIdToProgress := make(map[int32][]int32) // 任务进度

	if row != nil {
		chapter = row.Chapter

		if row.MainTask.Data() != nil {
			taskIdToProgress = row.MainTask.Data()
		}
	}

	if chapter <= 0 {
		chapter = 1
	}

	eventSet := util.NewSet[int32]()
	eventSet.AddValue(constants.FixedValueEvents)

	var isFixedValue bool // 是否是固定值判断
	if eventSet.Contains(taskEvent) {
		isFixedValue = true
	} else {
		isFixedValue = false
	}

	hasUpdate := false        // 是否有进度、状态更新
	hasChapterUpdate := false // 当前正在进行的章节是否有任务进度、状态更新

	// 遍历主线任务-当前事件下的所有任务
	for taskId, taskVal := range baseTaskList {
		if len(taskVal.Value) <= 0 {
			continue
		}

		// 配置达标的参数条件
		requiredChapter := taskVal.Chapter // 章节
		requiredCount := taskVal.Count     // 1,可以提前计入进度;2,接受到任务才开始计入

		// 已完成的章节任务,不做处理
		if requiredChapter < chapter {
			continue
		}

		// 不是当前章节的任务,不做处理
		if requiredCount == 2 && requiredChapter > chapter {
			continue
		}

		var requiredLimit int32

		if len(taskVal.Value) >= 2 {
			requiredId := taskVal.Value[0]   // 达标 建筑id或关卡id
			requiredLimit = taskVal.Value[1] // 达标 次数或星级

			// 建筑或者关卡id不匹配，不做任务处理
			if requiredId != 0 && requiredId != id {
				continue
			}
		} else {
			requiredLimit = taskVal.Value[0] // 达标次数
		}

		taskProgress, exists := taskIdToProgress[taskId]
		if exists {
			if taskProgress[2] >= 1 { // 已完成或者已领取,不做任务处理
				continue
			}

			var newProgress int32
			if isFixedValue { // 如果是固定值判断
				newProgress = num // 最新等级、星级
			} else {
				newProgress = taskProgress[1] + num // 最新进度
			}

			if newProgress >= requiredLimit {
				newProgress = requiredLimit

				taskIdToProgress[taskId][1] = newProgress // 更新进度
				taskIdToProgress[taskId][2] = 1           // 更新任务状态
			} else {
				if isFixedValue { // 如果是固定值判断
					if newProgress > taskProgress[1] {
						taskIdToProgress[taskId][1] = newProgress // 更新进度
					}
				} else {
					taskIdToProgress[taskId][1] = newProgress // 更新进度
				}
			}
		} else {
			if num >= requiredLimit {
				taskIdToProgress[taskId] = []int32{taskId, requiredLimit, 1} // 保存新任务进度、状态
			} else {
				taskIdToProgress[taskId] = []int32{taskId, num, 0} // 保存新任务进度
			}
		}

		hasUpdate = true // 有任务进度、状态更新
		if chapter == requiredChapter {
			hasChapterUpdate = true // 当前章节有任务进度更新，需要推送下行
		}
	}

	if hasUpdate {
		taskInfo := task_info_dao.TaskInfo{
			RoleId:   roleId,
			Chapter:  chapter,
			MainTask: datatypes.NewJSONType(taskIdToProgress),
		}

		task_info_dao.UpdateTaskInfo(&taskInfo, fields) // 修改任务状态

		if hasChapterUpdate {
			msgS2C := ServiceObj.GetMainTaskChapterInfo.GetMainTaskChapterInfoS2c(roleId)
			conn.SendBuffPBMsg(uint32(pb.ProtocolManager_GetMainTaskChapterInfo), msgS2C)
		}
	}

	return pb.ErrorCodeManager_SUCCESS
}
